{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Start here to begin with Stingray."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "%matplotlib inline\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a light curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from stingray import Lightcurve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `Lightcurve` object is usually created in one of the following two ways:\n",
    "\n",
    "1. From an array of time stamps and an array of counts.\n",
    "        \n",
    "        lc = Lightcurve(times, counts, **opts)\n",
    "\n",
    "    where `**opts` are any (optional) keyword arguments (e.g. `dt=0.1`, `mjdref=55000`, etc.)\n",
    "\n",
    "2. From photon arrival times.\n",
    "\n",
    "        lc = Lightcurve.make_lightcurve(event_arrival_times, dt=1, **opts)\n",
    "\n",
    "as will be described in the next sections.\n",
    "\n",
    "An additional possibility is creating an empty `Lightcurve` object, whose attributes will be filled in later:\n",
    "\n",
    "    lc = Lightcurve()\n",
    "\n",
    "or, if one wants to specify any keyword arguments:\n",
    "\n",
    "    lc = Lightcurve(**opts)\n",
    "\n",
    " This option is usually only relevant to advanced users, but we mention it here for reference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Array of time stamps and counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create 1000 time stamps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "times = np.arange(1000)\n",
    "times[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create 1000 random Poisson-distributed counts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 91,  98,  98,  98, 108,  86, 101, 114,  93,  95])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts = np.random.poisson(100, size=len(times))\n",
    "counts[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a Lightcurve object with the times and counts array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Checking if light curve is well behaved. This can take time, so if you are sure it is already sorted, specify skip_checks=True at light curve creation.\n",
      "WARNING:root:Checking if light curve is sorted.\n",
      "WARNING:root:Computing the bin time ``dt``. This can take time. If you know the bin time, please specify it at light curve creation\n"
     ]
    }
   ],
   "source": [
    "lc = Lightcurve(times, counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of data points can be counted with the `len` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the warnings thrown by the syntax above. By default, `stingray` does a number of checks on the data that is put into the `Lightcurve` class. For example, it checks whether it's evenly sampled. It also computes the time resolution `dt`. All of these checks take time. If you know the time resolution, it's a good idea to put it in manually. If you know that your light curve is well-behaved (for example, because you know the data really well, or because you've generated it yourself, as we've done above), you can skip those checks and save a bit of time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt = 1 \n",
    "lc = Lightcurve(times, counts, dt=dt, skip_checks=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Photon Arrival Times\n",
    "\n",
    "Often, you might have unbinned photon arrival times, rather than a light curve with time stamps and associated measurements. If this is the case, you can use the `make_lightcurve` method to turn these photon arrival times into a regularly binned light curve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 2., 2., 2., 3., 3., 3., 3., 3.])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arrivals = np.loadtxt(\"photon_arrivals.txt\")\n",
    "arrivals[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_new = Lightcurve.make_lightcurve(arrivals, dt=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The time bins and respective counts can be seen with `lc.counts` and `lc.time`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 5, 1, 4, 1, 3, 1, 1])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc_new.counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc_new.time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One useful feature is that you can explicitly pass in the start time and the duration of the observation. This can be helpful because the chance that a photon will arrive exactly at the start of the observation and the end of the observation is very small. In practice, when making multiple light curves from the same observation (e.g. individual light curves of multiple detectors, of for different energy ranges) this can lead to the creation of light curves with time bins that are *slightly* offset from one another. Here, passing in the total duration of the observation and the start time can be helpful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_new = Lightcurve.make_lightcurve(arrivals, dt=1.0, tstart=1.0, tseg=9.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Properties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Lightcurve object has the following properties :\n",
    "\n",
    "1. `time` : numpy array of time values\n",
    "2. `counts` : numpy array of counts per bin values\n",
    "3. `counts_err`: numpy array with the uncertainties on the values in `counts`\n",
    "4. `countrate` : numpy array of counts per second\n",
    "5. `countrate_err`: numpy array of the uncertainties on the values in `countrate`\n",
    "4. `n` : Number of data points in the lightcurve\n",
    "5. `dt` : Time resolution of the light curve\n",
    "6. `tseg` : Total duration of the light curve\n",
    "7. `tstart` : Start time of the light curve\n",
    "8. `meancounts`: The mean counts of the light curve\n",
    "9. `meanrate`: The mean count rate of the light curve\n",
    "10. `mjdref`: MJD reference date (``tstart`` / 86400 gives the date in MJD at the start of the observation)\n",
    "11. `gti`:Good Time Intervals. They indicate the \"safe\" time intervals to be used during the analysis of the light curve. \n",
    "12. `err_dist`: Statistic of the Lightcurve, it is used to calculate the uncertainties and other statistical values appropriately. It propagates to Spectrum classes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc.n == len(lc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that by default, `stingray` assumes that the user is passing a light curve in **counts per bin**. That is, the counts in bin $i$ will be the number of photons that arrived in the interval $t_i - 0.5\\Delta t$ and $t_i + 0.5\\Delta t$. Sometimes, data is given in **count rate**, i.e. the number of events that arrive within an interval of a *second*. The two will only be the same if the time resolution of the light curve is exactly 1 second.\n",
    "\n",
    "Whether the input data is in counts per bin or in count rate can be toggled via the boolean `input_counts` keyword argument. By default, this argument is set to `True`, and the code assumes the light curve passed into the object is in counts/bin. By setting it to `False`, the user can pass in count rates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# times with a resolution of 0.1\n",
    "dt = 0.1\n",
    "times = np.arange(0, 100, dt)\n",
    "times[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_countrate = 100.0\n",
    "countrate = np.random.poisson(mean_countrate, size=len(times))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc = Lightcurve(times, counts=countrate, dt=dt, skip_checks=True, input_counts=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Internally, both `counts` and `countrate` attribute will be defined no matter what the user passes in, since they're trivially converted between each other through a multiplication/division with `dt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100.0\n",
      "[113  92 110  97 101 102 103 101 124  89]\n"
     ]
    }
   ],
   "source": [
    "print(mean_countrate)\n",
    "print(lc.countrate[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n",
      "[11.3  9.2 11.   9.7 10.1 10.2 10.3 10.1 12.4  8.9]\n"
     ]
    }
   ],
   "source": [
    "mean_counts = mean_countrate * dt\n",
    "print(mean_counts)\n",
    "print(lc.counts[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Error Distributions in `stingray.Lightcurve`\n",
    "\n",
    "The instruments that record our data impose measurement noise on our measurements. Depending on the type of instrument, the statistical distribution of that noise can be different. `stingray` was originally developed with X-ray data in mind, where most data comes in the form of _photon arrival times_, which generate measurements distributed according to a Poisson distribution. By default, `err_dist` is assumed to Poisson, and this is the only statistical distribution currently fully supported. But you *can* put in your own errors (via `counts_err` or `countrate_err`). It'll produce a warning, and be aware that some of the statistical assumptions made about downstream products (e.g. the normalization of periodograms) may not be correct:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "times = np.arange(1000)\n",
    "\n",
    "mean_flux = 100.0 # mean flux\n",
    "std_flux = 2.0 # standard deviation on the flux\n",
    "\n",
    "# generate fluxes with a Gaussian distribution and \n",
    "# an array of associated uncertainties\n",
    "flux = np.random.normal(loc=mean_flux, scale=std_flux, size=len(times)) \n",
    "flux_err = np.ones_like(flux) * std_flux"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc = Lightcurve(times, flux, err=flux_err, err_dist=\"gauss\", dt=1.0, skip_checks=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Good Time Intervals\n",
    "\n",
    "`Lightcurve` (and most other core `stingray` classes) support the use of *Good Time Intervals* (or GTIs), which denote the parts of an observation that are reliable for scientific purposes. Often, GTIs introduce gaps (e.g. where the instrument was off, or affected by solar flares). By default. GTIs are passed and don't apply to the data within a `Lightcurve` object, but become relevant in a number of circumstances, such as when generating `Powerspectrum` objects. \n",
    "\n",
    "If no GTIs are given at instantiation of the `Lightcurve` class, an artificial GTI will be created spanning the entire length of the data set being passed in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "times = np.arange(1000)\n",
    "counts = np.random.poisson(100, size=len(times))\n",
    "\n",
    "lc = Lightcurve(times, counts, dt=1, skip_checks=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5.000e-01,  9.995e+02]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc.gti"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "999\n",
      "[[-5.000e-01  9.995e+02]]\n"
     ]
    }
   ],
   "source": [
    "print(times[0]) # first time stamp in the light curve\n",
    "print(times[-1]) # last time stamp in the light curve\n",
    "print(lc.gti) # the GTIs generated within Lightcurve"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "GTIs are defined as a list of tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "gti = [(0, 500), (600, 1000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc = Lightcurve(times, counts, dt=1, skip_checks=True, gti=gti)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   0  500]\n",
      " [ 600 1000]]\n"
     ]
    }
   ],
   "source": [
    "print(lc.gti)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll get back to these when we talk more about some of the methods that apply GTIs to the data.\n",
    "\n",
    "# Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Addition/Subtraction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two light curves can be summed up or subtracted from each other if they have same time arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc = Lightcurve(times, counts, dt=1, skip_checks=True)\n",
    "lc_rand = Lightcurve(np.arange(1000), [500]*1000, dt=1, skip_checks=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_sum = lc + lc_rand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counts in light curve 1: [103  99 102 109 104]\n",
      "Counts in light curve 2: [500 500 500 500 500]\n",
      "Counts in summed light curve: [603 599 602 609 604]\n"
     ]
    }
   ],
   "source": [
    "print(\"Counts in light curve 1: \" + str(lc.counts[:5]))\n",
    "print(\"Counts in light curve 2: \" + str(lc_rand.counts[:5]))\n",
    "print(\"Counts in summed light curve: \" + str(lc_sum.counts[:5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Negation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A negation operation on the lightcurve object inverts the count array from positive to negative values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_neg = -lc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_sum = lc + lc_neg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(lc_sum.counts == 0)  # All the points on lc and lc_neg cancel each other"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Count value at a particular time can be obtained using indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "113"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc[120]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Lightcurve can also be sliced to generate a new object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_sliced = lc[100:200]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lc_sliced.counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concatenation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two light curves can be combined into a single object using the `join` method. Note that both of them must not have overlapping time arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_1 = lc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_2 = Lightcurve(np.arange(1000, 2000), np.random.rand(1000)*1000, dt=1, skip_checks=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_long = lc_1.join(lc_2, skip_checks=True)  # Or vice-versa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2000\n"
     ]
    }
   ],
   "source": [
    "print(len(lc_long))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Truncation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A light curve can also be truncated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_cut = lc_long.truncate(start=0, stop=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lc_cut)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note** : By default, the `start` and `stop` parameters are assumed to be given as **indices** of the time array. However, the `start` and `stop` values can also be given as time values in the same value as the time array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_cut = lc_long.truncate(start=500, stop=1500, method='time')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500, 1499)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc_cut.time[0], lc_cut.time[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Re-binning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The time resolution (`dt`) can also be changed to a larger value.\n",
    "\n",
    "**Note** : While the new resolution need not be an integer multiple of the previous time resolution, be aware that if it is not, the last bin will be cut off by the fraction left over by the integer division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_rebinned = lc_long.rebin(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old time resolution = 1\n",
      "Number of data points = 2000\n",
      "New time resolution = 2\n",
      "Number of data points = 1000\n"
     ]
    }
   ],
   "source": [
    "print(\"Old time resolution = \" + str(lc_long.dt))\n",
    "print(\"Number of data points = \" + str(lc_long.n))\n",
    "print(\"New time resolution = \" + str(lc_rebinned.dt))\n",
    "print(\"Number of data points = \" + str(lc_rebinned.n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A lightcurve can be sorted using the `sort` method. This function sorts `time` array and the `counts` array is changed accordingly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_lc_long = lc_long[:]  # Copying into a new object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_lc_long = new_lc_long.sort(reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_lc_long.time[0] == max(lc_long.time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can sort by the `counts` array using `sort_counts` method which changes `time` array accordingly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_lc = lc_long[:]\n",
    "new_lc = new_lc.sort_counts()\n",
    "new_lc.counts[-1] == max(lc_long.counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A curve can be plotted with the `plot` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lc.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A plot can also be customized using several keyword arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lc.plot(labels=('Time', \"Counts\"),  # (xlabel, ylabel)\n",
    "        axis=(0, 1000, -50, 150),  # (xmin, xmax, ymin, ymax)\n",
    "        title=\"Random generated lightcurve\",\n",
    "        marker='c:')  # c is for cyan and : is the marker style"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The figure drawn can also be saved in a file using keywords arguments in the plot method itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lc.plot(marker = 'k', save=True, filename=\"lightcurve.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note** : See `utils.savefig` function for more options on saving a file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sample Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stingray also has a sample `Lightcurve` data which can be imported from within the library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "from stingray import sampledata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Checking if light curve is well behaved. This can take time, so if you are sure it is already sorted, specify skip_checks=True at light curve creation.\n",
      "WARNING:root:Checking if light curve is sorted.\n",
      "WARNING:root:Computing the bin time ``dt``. This can take time. If you know the bin time, please specify it at light curve creation\n"
     ]
    }
   ],
   "source": [
    "lc = sampledata.sample_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lc.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checking the Light Curve for Irregularities\n",
    "\n",
    "You can perform checks on the behaviour of the light curve, similar to what's done when instantiating a `Lightcurve` object when `skip_checks=False`, by calling the relevant method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "time = np.hstack([np.arange(0, 10, 0.1), np.arange(10, 20, 0.3)]) # uneven time resolution\n",
    "counts = np.random.poisson(100, size=len(time))\n",
    "\n",
    "lc = Lightcurve(time, counts, dt=1.0, skip_checks=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc.check_lightcurve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add some badly formatted GTIs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "gti = [(10, 100), (20, 30, 40), ((1, 2), (3, 4, (5, 6)))] # not a well-behaved GTI\n",
    "lc = Lightcurve(time, counts, dt=0.1, skip_checks=True, gti=gti)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Please check formatting of GTIs. They need to be provided as [[gti00, gti01], [gti10, gti11], ...]",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-59-7e2c226c1569>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheck_lightcurve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/opt/miniconda3/envs/stingraydev/lib/python3.8/site-packages/stingray-0.3.dev267+gc5fd28c.d20210122-py3.8.egg/stingray/lightcurve.py\u001b[0m in \u001b[0;36mcheck_lightcurve\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    418\u001b[0m         \u001b[0;31m# i.e. the bin sizes aren't equal throughout.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 420\u001b[0;31m         \u001b[0mcheck_gtis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgti\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    421\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    422\u001b[0m         \u001b[0midxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msearchsorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgti\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/miniconda3/envs/stingraydev/lib/python3.8/site-packages/stingray-0.3.dev267+gc5fd28c.d20210122-py3.8.egg/stingray/gti.py\u001b[0m in \u001b[0;36mcheck_gtis\u001b[0;34m(gti)\u001b[0m\n\u001b[1;32m    225\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgti\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mgti\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgti\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;32mor\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    226\u001b[0m             \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgti\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mgti\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 227\u001b[0;31m         raise TypeError(\"Please check formatting of GTIs. They need to be\"\n\u001b[0m\u001b[1;32m    228\u001b[0m                         \" provided as [[gti00, gti01], [gti10, gti11], ...]\")\n\u001b[1;32m    229\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: Please check formatting of GTIs. They need to be provided as [[gti00, gti01], [gti10, gti11], ...]"
     ]
    }
   ],
   "source": [
    "lc.check_lightcurve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MJDREF and Shifting Times\n",
    "\n",
    "The `mjdref` keyword argument defines a reference time in Modified Julian Date. Often, X-ray missions count their internal time in seconds from a given reference date and time (so that numbers don't become arbitrarily large). The data is then in the format of Mission Elapsed Time (MET), or seconds since that reference time. \n",
    "\n",
    "`mjdref` is generally passed into the `Lightcurve` object at instantiation, but it can be changed later:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "91254\n"
     ]
    }
   ],
   "source": [
    "mjdref = 91254\n",
    "time = np.arange(1000)\n",
    "counts = np.random.poisson(100, size=len(time))\n",
    "\n",
    "lc = Lightcurve(time, counts, dt=1, skip_checks=True, mjdref=mjdref)\n",
    "print(lc.mjdref)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "91274\n"
     ]
    }
   ],
   "source": [
    "mjdref_new = 91254 + 20\n",
    "lc_new = lc.change_mjdref(mjdref_new)\n",
    "print(lc_new.mjdref)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This change only affects the *reference time*, not the values given in the `time` attribute. However, it is also possible to shift the *entire light curve*, along with its GTIs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "gti = [(0,500), (600, 1000)]\n",
    "lc.gti = gti"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first three time bins: [0 1 2]\n",
      "GTIs: [[   0  500]\n",
      " [ 600 1000]]\n"
     ]
    }
   ],
   "source": [
    "print(\"first three time bins: \" + str(lc.time[:3]))\n",
    "print(\"GTIs: \" + str(lc.gti))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_shift = 10.0\n",
    "lc_shifted = lc.shift(time_shift)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shifted first three time bins: [10. 11. 12.]\n",
      "Shifted GTIs: [[  10.  510.]\n",
      " [ 610. 1010.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Shifted first three time bins: \" + str(lc_shifted.time[:3]))\n",
    "print(\"Shifted GTIs: \" + str(lc_shifted.gti))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating a baseline\n",
    "\n",
    "**TODO**: Need to document this method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with GTIs and Splitting Light Curves\n",
    "\n",
    "It is possible to split light curves into multiple segments. In particular, it can be useful to split light curves with large gaps into individual contiguous segments without gaps. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Computing the bin time ``dt``. This can take time. If you know the bin time, please specify it at light curve creation\n"
     ]
    }
   ],
   "source": [
    "# make a time array with a big gap and a small gap\n",
    "time = np.array([1, 2, 3, 10, 11, 12, 13, 14, 17, 18, 19, 20])\n",
    "counts = np.random.poisson(100, size=len(time))\n",
    "\n",
    "lc = Lightcurve(time, counts, skip_checks=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.5, 20.5]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc.gti"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This light curve has uneven bins. It has a large gap between 3 and 10, and a smaller gap between 14 and 17. We can use the `split` method to split it into three contiguous segments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_split = lc.split(min_gap=2*lc.dt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[10 11 12 13 14]\n",
      "[17 18 19 20]\n"
     ]
    }
   ],
   "source": [
    "for lc_tmp in lc_split:\n",
    "    print(lc_tmp.time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This has split the light curve into three contiguous segments. You can adjust the tolerance for the size of gap that's acceptable via the `min_gap` attribute. You can also require a minimum number of data points in the output light curves. This is helpful when you're only interested in contiguous segments of a certain length:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_split = lc.split(min_gap=6.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[10 11 12 13 14 17 18 19 20]\n"
     ]
    }
   ],
   "source": [
    "for lc_tmp in lc_split:\n",
    "    print(lc_tmp.time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we only want the long segment?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_split = lc.split(min_gap=6.0, min_points=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 11 12 13 14 17 18 19 20]\n"
     ]
    }
   ],
   "source": [
    "for lc_tmp in lc_split:\n",
    "    print(lc_tmp.time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A special case of splitting your light curve object is to split by GTIs. This can be helpful if you want to look at individual contiguous segments separately:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a time array with a big gap and a small gap\n",
    "time = np.arange(20)\n",
    "counts = np.random.poisson(100, size=len(time))\n",
    "gti = [(0,8), (12,20)]\n",
    "\n",
    "\n",
    "lc = Lightcurve(time, counts, dt=1, skip_checks=True, gti=gti)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_split = lc.split_by_gti()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7]\n",
      "[13 14 15 16 17 18 19]\n"
     ]
    }
   ],
   "source": [
    "for lc_tmp in lc_split:\n",
    "    print(lc_tmp.time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because I'd passed in GTIs that define the range from 0-8 and from 12-20 as good time intervals, the light curve will be split into two individual ones containing all data points falling within these ranges.\n",
    "\n",
    "You can also apply the GTIs *directly* to the original light curve, which will filter `time`, `counts`, `countrate`, `counts_err` and `countrate_err` to only fall within the bounds of the GTIs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a time array with a big gap and a small gap\n",
    "time = np.arange(20)\n",
    "counts = np.random.poisson(100, size=len(time))\n",
    "gti = [(0,8), (12,20)]\n",
    "\n",
    "\n",
    "lc = Lightcurve(time, counts, dt=1, skip_checks=True, gti=gti)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Caution**: This is one of the few methods that change the original state of the object, rather than returning a new copy of it with the changes applied! So any events falling outside of the range of the GTIs will be lost:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# time array before applying GTIs:\n",
    "lc.time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc.apply_gtis()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7, 13, 14, 15, 16, 17, 18, 19])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# time array after applying GTIs\n",
    "lc.time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the time bins 8-12 have been dropped, since they fall outside of the GTIs. \n",
    "\n",
    "## Analyzing Light Curve Segments\n",
    "\n",
    "There's some functionality in `stingray` aimed at making analysis of individual light curve segments (or chunks, as they're called throughout the code) efficient. \n",
    "\n",
    "One helpful function tells you the length that segments should have to satisfy two conditions: (1) the minimum number of time bins in the segment, and (2) the minimum total number of counts (or flux) in each segment.\n",
    "\n",
    "Let's give this a try with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt=1.0\n",
    "time = np.arange(0, 100, dt)\n",
    "counts = np.random.poisson(100, size=len(time))\n",
    "\n",
    "lc = Lightcurve(time, counts, dt=dt, skip_checks=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The estimated length of each segment in seconds to satisfy both conditions is: 4.0\n"
     ]
    }
   ],
   "source": [
    "min_total_counts = 300\n",
    "min_total_bins = 2\n",
    "estimated_chunk_length = lc.estimate_chunk_length(min_total_counts, min_total_bins)\n",
    "\n",
    "print(\"The estimated length of each segment in seconds to satisfy both conditions is: \" + str(estimated_chunk_length))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we have time bins of 1 second time resolution, each with an average of 100 counts/bin. We require at least 2 time bins in each segment, and also a minimum number of total counts in the segment of 300. In theory, you'd expect to need 3 time bins (so 3-second segments) to satisfy the condition above. However, the Poisson distribution is quite variable, so we cannot guarantee that all bins will have a total number of counts above 300. Hence, our segments need to be 4 seconds long. \n",
    "\n",
    "We can now use these segments to do some analysis, using the `analyze_by_chunks` method. In the simplest, case we can use a standard `numpy` operation to learn something about the properties of each segment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_times, stop_times, lc_sums = lc.analyze_lc_chunks(chunk_length = 10.0, func=np.median)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([102. , 110. ,  92. ,  96.5,  99.5, 100. ,  95. ,  96.5, 100. ,\n",
       "       108. ])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc_sums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This splits the light curve into 10-second segments, and then finds the median number of counts/bin in each segment. For a flat light curve like the one we generated above, this isn't super interesting, but this method can be helpful for more complex analyses. Instead of `np.median`, you can also pass in your own function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(lc):\n",
    "    \"\"\"\n",
    "    Not a very interesting function\n",
    "    \"\"\"\n",
    "    return np.sum(lc.counts) * 10.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_times, stop_times, lc_result = lc.analyze_lc_chunks(chunk_length=10.0, func=myfunc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10090., 10830.,  9370., 10120., 10180., 10190.,  9910.,  9610.,\n",
       "        9880., 10600.])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compatibility with `Lightkurve`\n",
    "\n",
    "The [`Lightkurve` package](https://docs.lightkurve.org) provides a large amount of complementary functionality to stingray, in particular for data observed with Kepler and TESS, stars and exoplanets, and unevenly sampled data. We have implemented a conversion method that converts to/from `stingray`'s native `Lightcurve` object and `Lightkurve`'s native `LightCurve` object. Equivalent functionality exists in `Lightkurve`, too. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "import lightkurve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc_new = lc.to_lightkurve()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "lightkurve.lightcurve.LightCurve"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(lc_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n",
       "       13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,\n",
       "       26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38.,\n",
       "       39., 40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 50., 51.,\n",
       "       52., 53., 54., 55., 56., 57., 58., 59., 60., 61., 62., 63., 64.,\n",
       "       65., 66., 67., 68., 69., 70., 71., 72., 73., 74., 75., 76., 77.,\n",
       "       78., 79., 80., 81., 82., 83., 84., 85., 86., 87., 88., 89., 90.,\n",
       "       91., 92., 93., 94., 95., 96., 97., 98., 99.])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc_new.time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([110,  82,  94, 126, 102,  80, 102, 105, 106, 102, 119,  98, 112,\n",
       "        98, 119, 112, 119,  99,  99, 108,  91,  85,  93, 109,  97,  82,\n",
       "        87,  89,  96, 108, 120,  88,  97,  88, 109, 120,  94, 106,  94,\n",
       "        96, 120, 122,  92,  87, 113,  94, 100,  99, 105,  86, 107, 101,\n",
       "        94, 102,  96, 112,  93, 117,  99,  98,  91, 101,  94, 120, 105,\n",
       "        91,  91,  96,  85, 117, 104, 102,  91,  94, 100, 115,  98,  74,\n",
       "        95,  88, 100, 107, 102, 109, 109,  94,  86,  84,  97, 100, 110,\n",
       "       109, 117,  96, 108, 108, 110, 108,  97,  97])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc_new.flux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do the rountrip to stingray:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Checking if light curve is well behaved. This can take time, so if you are sure it is already sorted, specify skip_checks=True at light curve creation.\n",
      "WARNING:root:Checking if light curve is sorted.\n",
      "WARNING:root:Computing the bin time ``dt``. This can take time. If you know the bin time, please specify it at light curve creation\n"
     ]
    }
   ],
   "source": [
    "lc_back = lc_new.to_stingray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n",
       "       13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,\n",
       "       26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38.,\n",
       "       39., 40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 50., 51.,\n",
       "       52., 53., 54., 55., 56., 57., 58., 59., 60., 61., 62., 63., 64.,\n",
       "       65., 66., 67., 68., 69., 70., 71., 72., 73., 74., 75., 76., 77.,\n",
       "       78., 79., 80., 81., 82., 83., 84., 85., 86., 87., 88., 89., 90.,\n",
       "       91., 92., 93., 94., 95., 96., 97., 98., 99.])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc_back.time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([110.,  82.,  94., 126., 102.,  80., 102., 105., 106., 102., 119.,\n",
       "        98., 112.,  98., 119., 112., 119.,  99.,  99., 108.,  91.,  85.,\n",
       "        93., 109.,  97.,  82.,  87.,  89.,  96., 108., 120.,  88.,  97.,\n",
       "        88., 109., 120.,  94., 106.,  94.,  96., 120., 122.,  92.,  87.,\n",
       "       113.,  94., 100.,  99., 105.,  86., 107., 101.,  94., 102.,  96.,\n",
       "       112.,  93., 117.,  99.,  98.,  91., 101.,  94., 120., 105.,  91.,\n",
       "        91.,  96.,  85., 117., 104., 102.,  91.,  94., 100., 115.,  98.,\n",
       "        74.,  95.,  88., 100., 107., 102., 109., 109.,  94.,  86.,  84.,\n",
       "        97., 100., 110., 109., 117.,  96., 108., 108., 110., 108.,  97.,\n",
       "        97.])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc_back.counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can transform `Lightcurve` objects to and from `astropy.TimeSeries` objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt=1.0\n",
    "time = np.arange(0, 100, dt)\n",
    "counts = np.random.poisson(100, size=len(time))\n",
    "\n",
    "lc = Lightcurve(time, counts, dt=dt, skip_checks=True)\n",
    "\n",
    "# convet to astropy.TimeSeries object\n",
    "ts = lc.to_astropy_timeseries()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "astropy.timeseries.sampled.TimeSeries"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(ts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<i>TimeSeries length=10</i>\n",
       "<table id=\"table140573414427472\" class=\"table-striped table-bordered table-condensed\">\n",
       "<thead><tr><th>time</th><th>counts</th></tr></thead>\n",
       "<thead><tr><th>object</th><th>int64</th></tr></thead>\n",
       "<tr><td>0.0</td><td>100</td></tr>\n",
       "<tr><td>1.1574074074074073e-05</td><td>92</td></tr>\n",
       "<tr><td>2.3148148148148147e-05</td><td>98</td></tr>\n",
       "<tr><td>3.472222222222222e-05</td><td>85</td></tr>\n",
       "<tr><td>4.6296296296296294e-05</td><td>113</td></tr>\n",
       "<tr><td>5.787037037037037e-05</td><td>94</td></tr>\n",
       "<tr><td>6.944444444444444e-05</td><td>99</td></tr>\n",
       "<tr><td>8.101851851851852e-05</td><td>108</td></tr>\n",
       "<tr><td>9.259259259259259e-05</td><td>101</td></tr>\n",
       "<tr><td>0.00010416666666666667</td><td>117</td></tr>\n",
       "</table>"
      ],
      "text/plain": [
       "<TimeSeries length=10>\n",
       "         time          counts\n",
       "        object         int64 \n",
       "---------------------- ------\n",
       "                   0.0    100\n",
       "1.1574074074074073e-05     92\n",
       "2.3148148148148147e-05     98\n",
       " 3.472222222222222e-05     85\n",
       "4.6296296296296294e-05    113\n",
       " 5.787037037037037e-05     94\n",
       " 6.944444444444444e-05     99\n",
       " 8.101851851851852e-05    108\n",
       " 9.259259259259259e-05    101\n",
       "0.00010416666666666667    117"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lc_back = Lightcurve.from_astropy_timeseries(ts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading/Writing Lightcurves to/from files\n",
    "\n",
    "The `Lightcurve` class has some rudimentary reading/writing capabilities via the `read` and `write` methods. For more information `stingray` inputs and outputs, please refer to the I/O tutorial."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}